package org.officelaf;

/**
 *
 * @author mikael
 */

import org.jvnet.flamingo.ribbon.JRibbon;
import org.officelaf.options.OfficeLAFPanel;
import org.officelaf.ribbon.MainRibbon;
import org.openide.util.NbPreferences;

import javax.swing.*;
import javax.swing.event.MouseInputListener;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
import javax.swing.plaf.BorderUIResource;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.basic.BasicRootPaneUI;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.RoundRectangle2D;
import java.beans.PropertyChangeEvent;
import java.util.ArrayList;
import java.util.List;

/**
 * User: mikael
 * Date: Sep 18, 2006
 * Time: 5:08:34 PM
 */
public class OfficeRootPaneUI extends BasicRootPaneUI {

    /** Keys to lookup borders in defaults table. */
    private static final String[] borderKeys = new String[]{
        null,
        "RootPane.frameBorder",              "RootPane.plainDialogBorder",
        "RootPane.informationDialogBorder",  "RootPane.errorDialogBorder",
        "RootPane.colorChooserDialogBorder", "RootPane.fileChooserDialogBorder",
        "RootPane.questionDialogBorder",     "RootPane.warningDialogBorder"
    };
    /** The amount of space (in pixels) that the cursor is changed on. */
    private static final int CORNER_DRAG_WIDTH = 16;
    /** Region from edges that dragging is active from. */
    private static final int BORDER_DRAG_THICKNESS = 5;
    private static boolean isFirst = true;
    /** Window the <code>JRootPane</code> is in. */
    private Window window;
    /**
     * <code>JComponent</code> providing window decorations. This will be
     * null if not providing window decorations.
     */
    private OfficeTitlePane titlePane;
    /**
     * <code>MouseInputListener</code> that is added to the parent
     * <code>Window</code> the <code>JRootPane</code> is contained in.
     */
    private MouseInputListener mouseInputListener;
    /**
     * The <code>LayoutManager</code> that is set on the
     * <code>JRootPane</code>.
     */
    private LayoutManager layoutManager;
    /**
     * <code>LayoutManager</code> of the <code>JRootPane</code> before we
     * replaced it.
     */
    private LayoutManager savedOldLayout;
    /** <code>JRootPane</code> providing the look and feel for. */
    private JRootPane root;
    /**
     * <code>Cursor</code> used to track the cursor set by the user.
     * This is initially <code>Cursor.DEFAULT_CURSOR</code>.
     */
    private Cursor lastCursor = Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
    private JRibbon ribbon;

    public OfficeRootPaneUI(JRootPane root) {
        this.root = root;
    }

    /**
     * Creates a UI for a <code>JRootPane</code>.
     *
     * @param c the JRootPane the RootPaneUI will be created for
     * @return the RootPaneUI implementation for the passed in JRootPane
     */
    public static ComponentUI createUI(JComponent c) {
        return new OfficeRootPaneUI((JRootPane) c);
    }

    public JRibbon getRibbon() {
        if (ribbon == null) {
            MainRibbon example = new MainRibbon();
            example.setup();
            setRibbon(example);
        }
        return ribbon;
    }

    public void setRibbon(JRibbon ribbon) {
        JRibbon old = this.ribbon;
        if (old != null) {
            root.getLayeredPane().remove(old);
        }

        this.ribbon = ribbon;
        if (this.ribbon != null) {
            boolean isRibbonVisible = NbPreferences.forModule(OfficeLAFPanel.class).getBoolean("ribbonCheck", true);
            this.ribbon.setVisible(isRibbonVisible);
            this.ribbon.putClientProperty(JLayeredPane.LAYER_PROPERTY, 0);
            root.getLayeredPane().add(this.ribbon, 0);
        }
    }

    /**
     * Invokes supers implementation of <code>installUI</code> to install
     * the necessary state onto the passed in <code>JRootPane</code>
     * to render the metal look and feel implementation of
     * <code>RootPaneUI</code>. If
     * the <code>windowDecorationStyle</code> property of the
     * <code>JRootPane</code> is other than <code>JRootPane.NONE</code>,
     * this will add a custom <code>Component</code> to render the widgets to
     * <code>JRootPane</code>, as well as installing a custom
     * <code>Border</code> and <code>LayoutManager</code> on the
     * <code>JRootPane</code>.
     *
     * @param c the JRootPane to install state onto
     */
    public void installUI(JComponent c) {
        super.installUI(c);

        
        if (isFirst) {
            root.addHierarchyListener(new HierarchyListener() {
                public void hierarchyChanged(HierarchyEvent e) {
                    if (root == null) {
                        return;
                    }
                    Window w = SwingUtilities.getWindowAncestor(root);
                    if (w instanceof Frame) {
                        final Frame f = (Frame) w;
                        if (f != null && !f.isDisplayable() && !f.isUndecorated() && isFirst) {
                            root.setWindowDecorationStyle(JRootPane.FRAME);
                            f.setUndecorated(true);

                            if("mac os x".compareToIgnoreCase(System.getProperty("os.name")) != 0) {
                                f.addComponentListener(new ComponentAdapter() {
                                    public void componentResized(ComponentEvent e) {
                                        if(f.getExtendedState() == Frame.MAXIMIZED_BOTH) {
                                            com.sun.awt.AWTUtilities.setWindowShape(f, null);
                                        } else {
                                            Shape shape = new RoundRectangle2D.Float(0, 0, f.getWidth(), f.getHeight(), 11f, 11f);
                                            com.sun.awt.AWTUtilities.setWindowShape(f, shape);
                                        }
                                    }

                                    @Override
                                    public void componentMoved(ComponentEvent e) {
                                        // Set the maximizedBounds as workaround for the maximization of undecorated frames bug:
                                        // Bug ID: 4737788
                                        // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4737788
                                        Rectangle screenBounds = f.getGraphicsConfiguration().getBounds();
                                        Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(f.getGraphicsConfiguration());
                                        Rectangle newBounds = new Rectangle(
                                                screenInsets.left,
                                                screenInsets.top,
                                                screenBounds.width - (screenInsets.left + screenInsets.right),
                                                screenBounds.height - (screenInsets.top + screenInsets.bottom)
                                        );

                                        if (screenInsets.left == 0 && screenInsets.right == 0 && screenInsets.top == 0 && screenInsets.bottom == 0) {
                                            f.setMaximizedBounds(null);
                                        } else {
                                            f.setMaximizedBounds(newBounds);
                                        }
                                    }
                                });
                            }
                            
                            root.removeHierarchyListener(this);
                            isFirst = false;
                        }
                    }
                }
            });
        }

        int style = root.getWindowDecorationStyle();
        if (style != JRootPane.NONE) {
            installClientDecorations(root);
        }
    }

    /**
     * Invokes supers implementation to uninstall any of its state. This will
     * also reset the <code>LayoutManager</code> of the <code>JRootPane</code>.
     * If a <code>Component</code> has been added to the <code>JRootPane</code>
     * to render the window decoration style, this method will remove it.
     * Similarly, this will revert the Border and LayoutManager of the
     * <code>JRootPane</code> to what it was before <code>installUI</code>
     * was invoked.
     *
     * @param c the JRootPane to uninstall state from
     */
    public void uninstallUI(JComponent c) {
        super.uninstallUI(c);
        uninstallClientDecorations(root);

        layoutManager = null;
        mouseInputListener = null;
        root = null;
    }

    /**
     * Installs the appropriate <code>Border</code> onto the
     * <code>JRootPane</code>.
     */
    public void installBorder(JRootPane root) {
        int style = root.getWindowDecorationStyle();

        if (style == JRootPane.NONE) {
            LookAndFeel.uninstallBorder(root);
        } else {
            LookAndFeel.installBorder(root, borderKeys[style]);
            int titleHeight = titlePane.getPreferredSize().height;
            BorderUIResource border = new BorderUIResource(
                    new RoundRectangleBorder(13f, 13f, titleHeight, titlePane.getBackgroundImage()));
            root.setBorder(border);
        }
    }

    /** Removes any border that may have been installed. */
    private void uninstallBorder(JRootPane root) {
        LookAndFeel.uninstallBorder(root);
    }

    /** Installs the necessary Listeners for client decorations. */
    private void installClientDecorationListeners(JRootPane root) {
        window = SwingUtilities.getWindowAncestor(root);
        if (window != null) {
            if (mouseInputListener != null) {
                uninstallClientDecorationListeners(root);
            }

            mouseInputListener = createMouseInputListener(root);
            root.addMouseListener(mouseInputListener);
            root.addMouseMotionListener(mouseInputListener);
            titlePane.addMouseListener(mouseInputListener);
            titlePane.addMouseMotionListener(mouseInputListener);
        }
    }

    /**
     * Uninstalls the necessary Listeners for client decorations. This may
     * be invoked without a corresponding installClientDecorationListeners.
     */
    private void uninstallClientDecorationListeners(JRootPane root) {
        if (window != null) {
            root.removeMouseListener(mouseInputListener);
            root.removeMouseMotionListener(mouseInputListener);
            if (titlePane != null) {
                titlePane.removeMouseListener(mouseInputListener);
                titlePane.removeMouseMotionListener(mouseInputListener);
            }
        }
    }

    /**
     * Installs the appropriate LayoutManager on the <code>JRootPane</code>
     * to render the window decorations.
     */
    private void installLayout(JRootPane root) {
        if (layoutManager == null) {
            layoutManager = createLayoutManager();
        }
        savedOldLayout = root.getLayout();
        root.setLayout(layoutManager);
    }

    /** Uninstalls the previously installed <code>LayoutManager</code>. */
    private void uninstallLayout(JRootPane root) {
        if (savedOldLayout != null) {
            root.setLayout(savedOldLayout);
            savedOldLayout = null;
        }
    }

    /**
     * Installs the necessary state onto the JRootPane to render client
     * decorations. This is ONLY invoked if the <code>JRootPane</code>
     * has a decoration style other than <code>JRootPane.NONE</code>.
     */
    private void installClientDecorations(JRootPane root) {
        setTitlePane(root, createTitlePane(root));
        installBorder(root);

        installClientDecorationListeners(root);
        installLayout(root);

        //ImageIcon toolBarIcon = new ImageIcon(OfficeWindowsLookAndFeel.class.getResource("images/exieborder2.png"));
        //ImageIcon officeButtonIcon = new ImageIcon(OfficeWindowsLookAndFeel.class.getResource("images/exie_officebutton.png"));

//        JLabel label = new JLabel(toolBarIcon);
//        label.setVerticalAlignment(SwingConstants.TOP);
//        label.setBounds(officeButtonIcon.getIconWidth() - 2, 3, toolBarIcon.getIconWidth(), toolBarIcon.getIconHeight());
//        label.setVisible(true);
//        label.putClientProperty(JLayeredPane.LAYER_PROPERTY, 1);
//        root.getLayeredPane().add(label, 1);

//        OfficeButton officeButton = getOfficeButton();
//        officeButton.setBounds(2, 7, officeButtonIcon.getIconWidth(), officeButtonIcon.getIconHeight());
//        officeButton.setVisible(true);
//        officeButton.putClientProperty(JLayeredPane.LAYER_PROPERTY, 1);
//        root.getLayeredPane().add(officeButton, 1);
//
////        officeFrameToolBar = new OfficeFrameToolBar();
//        officeFrameToolBar.setVisible(true);
//        officeFrameToolBar.putClientProperty(JLayeredPane.LAYER_PROPERTY, 1);
//        root.getLayeredPane().add(officeFrameToolBar, 1);
//        root.getLayeredPane().add(getRibbon(), 0);

        if (window != null) {
            root.revalidate();
            root.repaint();
        }
    }

    /**
     * Uninstalls any state that <code>installClientDecorations</code> has
     * installed.
     * <p/>
     * NOTE: This may be called if you haven't installed client decorations
     * yet (ie before <code>installClientDecorations</code> has been invoked).
     */
    private void uninstallClientDecorations(JRootPane root) {
        uninstallBorder(root);
        uninstallClientDecorationListeners(root);
        setTitlePane(root, null);
        uninstallLayout(root);
        // We have to revalidate/repaint root if the style is JRootPane.NONE
        // only. When we needs to call revalidate/repaint with other styles
        // the installClientDecorations is always called after this method
        // imediatly and it will cause the revalidate/repaint at the proper
        // time.
        int style = root.getWindowDecorationStyle();
        if (style == JRootPane.NONE) {
            root.repaint();
            root.revalidate();
        }
        // Reset the cursor, as we may have changed it to a resize cursor
        if (window != null) {
            window.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
        }
        window = null;
    }

    /**
     * Returns the <code>JComponent</code> to render the window decoration
     * style.
     */
    private OfficeTitlePane createTitlePane(final JRootPane root) {
        OfficeTitlePane retVal = new OfficeTitlePane(root, this);

        boolean isMenuVisible = NbPreferences.forModule(OfficeLAFPanel.class).getBoolean("menuCheck", false);
        if(!isMenuVisible) {
            retVal.addMouseListener(new MouseAdapter() {
                public void mousePressed(MouseEvent e) {
                    if (e.getButton() == MouseEvent.BUTTON3 && root.getJMenuBar() != null) {
                        JMenuBar bar = root.getJMenuBar();
                        final JPopupMenu p = new JPopupMenu();

                        final List<JMenu> menus = new ArrayList<JMenu>();
                        for (int i = 0; i < bar.getMenuCount(); i++) {
                            menus.add(bar.getMenu(i));
                        }
                        for (JMenu menu : menus) {
                            p.add(menu);
                        }

                        p.addPopupMenuListener(new PopupMenuListener() {

                            public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
                            }

                            public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
                                for (JMenu menu : menus) {
                                    root.getJMenuBar().add(menu);
                                }
                            }

                            public void popupMenuCanceled(PopupMenuEvent e) {
                            }
                        });

                        p.show(e.getComponent(), e.getX(), e.getY());
                    }
                }
            });
        }


        return retVal;
    }

    /**
     * Returns a <code>MouseListener</code> that will be added to the
     * <code>JRootPane</code> and title pane.
     */
    private MouseInputListener createMouseInputListener(JRootPane root) {
        return new MouseInputHandler();
    }

    /**
     * Returns a <code>LayoutManager</code> that will be set on the
     * <code>JRootPane</code>.
     */
    private LayoutManager createLayoutManager() {
        return new MetalRootLayout();
    }

    /**
     * Sets the window title pane -- the JComponent used to provide a plaf a
     * way to override the native operating system's window title pane with
     * one whose look and feel are controlled by the plaf.  The plaf creates
     * and sets this value; the default is null, implying a native operating
     * system window title pane.
     *
     * @param titlePane the <code>JComponent</code> to use for the window title pane.
     */
    private void setTitlePane(JRootPane root, OfficeTitlePane titlePane) {
        JLayeredPane layeredPane = root.getLayeredPane();
        JComponent oldTitlePane = getTitlePane();

        if (oldTitlePane != null) {
            oldTitlePane.setVisible(false);
            layeredPane.remove(oldTitlePane);
        }

        this.titlePane = titlePane;
        if (titlePane != null) {
            layeredPane.add(titlePane, JLayeredPane.FRAME_CONTENT_LAYER);
            titlePane.setVisible(true);
        }
    }

    /**
     * Returns the <code>JComponent</code> rendering the title pane. If this
     * returns null, it implies there is no need to render window decorations.
     *
     * @return the current window title pane, or null
     * @see #setTitlePane
     */
    private JComponent getTitlePane() {
        return titlePane;
    }

    /**
     * Returns the <code>JRootPane</code> we're providing the look and
     * feel for.
     */
    private JRootPane getRootPane() {
        return root;
    }

    /**
     * Invoked when a property changes. <code>MetalRootPaneUI</code> is
     * primarily interested in events originating from the
     * <code>JRootPane</code> it has been installed on identifying the
     * property <code>windowDecorationStyle</code>. If the
     * <code>windowDecorationStyle</code> has changed to a value other
     * than <code>JRootPane.NONE</code>, this will add a <code>Component</code>
     * to the <code>JRootPane</code> to render the window decorations, as well
     * as installing a <code>Border</code> on the <code>JRootPane</code>.
     * On the other hand, if the <code>windowDecorationStyle</code> has
     * changed to <code>JRootPane.NONE</code>, this will remove the
     * <code>Component</code> that has been added to the <code>JRootPane</code>
     * as well resetting the Border to what it was before
     * <code>installUI</code> was invoked.
     *
     * @param e A PropertyChangeEvent object describing the event source
     *          and the property that has changed.
     */
    public void propertyChange(PropertyChangeEvent e) {
        super.propertyChange(e);

        String propertyName = e.getPropertyName();
        if (propertyName == null) {
            return;
        }

        if (propertyName.equals("windowDecorationStyle")) {
            JRootPane root = (JRootPane) e.getSource();
            int style = root.getWindowDecorationStyle();

            // This is potentially more than needs to be done,
            // but it rarely happens and makes the install/uninstall process
            // simpler. MetalTitlePane also assumes it will be recreated if
            // the decoration style changes.
            uninstallClientDecorations(root);
            if (style != JRootPane.NONE) {
                installClientDecorations(root);
            }
        } else if (propertyName.equals("ancestor")) {
            uninstallClientDecorationListeners(root);
            if (((JRootPane) e.getSource()).getWindowDecorationStyle() != JRootPane.NONE) {
                installClientDecorationListeners(root);
            }
        }
    }

    /**
     * A custom layout manager that is responsible for the layout of
     * layeredPane, glassPane, menuBar and titlePane, if one has been
     * installed.
     */
    // NOTE: Ideally this would extends JRootPane.RootLayout, but that
    //       would force this to be non-static.
    private static class MetalRootLayout implements LayoutManager2 {

        /**
         * Returns the amount of space the layout would like to have.
         *
         * @param parent the Container for which this layout manager is being used
         * @return a Dimension object containing the layout's preferred size
         */
        public Dimension preferredLayoutSize(Container parent) {
            Dimension cpd,mbd , tpd;
            int cpWidth = 0;
            int cpHeight = 0;
            int mbWidth = 0;
            int mbHeight = 0;
            int tpWidth = 0;
            int tpHeight = 0;

            Insets i = parent.getInsets();
            JRootPane root = (JRootPane) parent;

            if (root.getContentPane() != null) {
                cpd = root.getContentPane().getPreferredSize();
            } else {
                cpd = root.getSize();
            }
            if (cpd != null) {
                cpWidth = cpd.width;
                cpHeight = cpd.height;
            }

            if (root.getJMenuBar() != null) {
                mbd = root.getJMenuBar().getPreferredSize();
                if (mbd != null) {
                    mbWidth = mbd.width;
                    mbHeight = mbd.height;
                }
            }

            if (root.getWindowDecorationStyle() != JRootPane.NONE &&
                    (root.getUI() instanceof OfficeRootPaneUI)) {
                JComponent titlePane = ((OfficeRootPaneUI) root.getUI()).getTitlePane();
                if (titlePane != null) {
                    tpd = titlePane.getPreferredSize();
                    if (tpd != null) {
                        tpWidth = tpd.width;
                        tpHeight = tpd.height;
                    }
                }
            }

            return new Dimension(Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
                    cpHeight + mbHeight + tpWidth + i.top + i.bottom);
        }

        /**
         * Returns the minimum amount of space the layout needs.
         *
         * @param parent the Container for which this layout manager is being used
         * @return a Dimension object containing the layout's minimum size
         */
        public Dimension minimumLayoutSize(Container parent) {
            Dimension cpd,mbd , tpd;
            int cpWidth = 0;
            int cpHeight = 0;
            int mbWidth = 0;
            int mbHeight = 0;
            int tpWidth = 0;
            int tpHeight = 0;
            Insets i = parent.getInsets();
            JRootPane root = (JRootPane) parent;

            if (root.getContentPane() != null) {
                cpd = root.getContentPane().getMinimumSize();
            } else {
                cpd = root.getSize();
            }
            if (cpd != null) {
                cpWidth = cpd.width;
                cpHeight = cpd.height;
            }

            if (root.getJMenuBar() != null) {
                mbd = root.getJMenuBar().getMinimumSize();
                if (mbd != null) {
                    mbWidth = mbd.width;
                    mbHeight = mbd.height;
                }
            }
            if (root.getWindowDecorationStyle() != JRootPane.NONE &&
                    (root.getUI() instanceof OfficeRootPaneUI)) {
                JComponent titlePane = ((OfficeRootPaneUI) root.getUI()).getTitlePane();
                if (titlePane != null) {
                    tpd = titlePane.getMinimumSize();
                    if (tpd != null) {
                        tpWidth = tpd.width;
                        tpHeight = tpd.height;
                    }
                }
            }

            return new Dimension(Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
                    cpHeight + mbHeight + tpWidth + i.top + i.bottom);
        }

        /**
         * Returns the maximum amount of space the layout can use.
         *
         * @param target the Container for which this layout manager is being used
         * @return a Dimension object containing the layout's maximum size
         */
        public Dimension maximumLayoutSize(Container target) {
            Dimension cpd,mbd , tpd;
            int cpWidth = Integer.MAX_VALUE;
            int cpHeight = Integer.MAX_VALUE;
            int mbWidth = Integer.MAX_VALUE;
            int mbHeight = Integer.MAX_VALUE;
            int tpWidth = Integer.MAX_VALUE;
            int tpHeight = Integer.MAX_VALUE;
            Insets i = target.getInsets();
            JRootPane root = (JRootPane) target;

            if (root.getContentPane() != null) {
                cpd = root.getContentPane().getMaximumSize();
                if (cpd != null) {
                    cpWidth = cpd.width;
                    cpHeight = cpd.height;
                }
            }

            if (root.getJMenuBar() != null) {
                mbd = root.getJMenuBar().getMaximumSize();
                if (mbd != null) {
                    mbWidth = mbd.width;
                    mbHeight = mbd.height;
                }
            }

            if (root.getWindowDecorationStyle() != JRootPane.NONE &&
                    (root.getUI() instanceof OfficeRootPaneUI)) {
                JComponent titlePane = ((OfficeRootPaneUI) root.getUI()).getTitlePane();
                if (titlePane != null) {
                    tpd = titlePane.getMaximumSize();
                    if (tpd != null) {
                        tpWidth = tpd.width;
                        tpHeight = tpd.height;
                    }
                }
            }

            int maxHeight = Math.max(Math.max(cpHeight, mbHeight), tpHeight);
            // Only overflows if 3 real non-MAX_VALUE heights, sum to > MAX_VALUE
            // Only will happen if sums to more than 2 billion units.  Not likely.
            if (maxHeight != Integer.MAX_VALUE) {
                maxHeight = cpHeight + mbHeight + tpHeight + i.top + i.bottom;
            }

            int maxWidth = Math.max(Math.max(cpWidth, mbWidth), tpWidth);
            // Similar overflow comment as above
            if (maxWidth != Integer.MAX_VALUE) {
                maxWidth += i.left + i.right;
            }

            return new Dimension(maxWidth, maxHeight);
        }

        /**
         * Instructs the layout manager to perform the layout for the specified
         * container.
         *
         * @param parent the Container for which this layout manager is being used
         */
        public void layoutContainer(Container parent) {
            JRootPane root = (JRootPane) parent;
            Rectangle b = root.getBounds();
            Insets i = root.getInsets();
            int nextY = 0;
            int w = b.width - i.right - i.left;
            int h = b.height - i.top - i.bottom;

            if (root.getLayeredPane() != null) {
                root.getLayeredPane().setBounds(i.left, i.top, w, h);
            }
            if (root.getGlassPane() != null) {
                root.getGlassPane().setBounds(i.left, i.top, w, h);
            }
            // Note: This is laying out the children in the layeredPane,
            // technically, these are not our children.
            if (root.getWindowDecorationStyle() != JRootPane.NONE && (root.getUI() instanceof OfficeRootPaneUI)) {
                OfficeRootPaneUI ui = (OfficeRootPaneUI) root.getUI();

                JComponent titlePane = ui.getTitlePane();
                if (titlePane != null) {
                    Dimension tpd = titlePane.getPreferredSize();
                    if (tpd != null) {
                        int tpHeight = tpd.height;
                        titlePane.setBounds(0, 0, w, tpHeight);
                        nextY += tpHeight;
                    }
                }

//                OfficeFrameToolBar toolbar = ui.getOfficeFrameToolBar();
//                Dimension ts = toolbar.getPreferredSize();
//                toolbar.setBounds(ui.getOfficeButton().getBounds().width - 2, 3, ts.width, OfficeFrameToolBar.BG_HEIGHT);

//                OfficeButton officeButton = ui.getOfficeButton();
//                ImageIcon officeButtonIcon = new ImageIcon(OfficeWindowsLookAndFeel.class.getResource("images/exie_officebutton.png"));
//                officeButton.setBounds(2, 7, officeButtonIcon.getIconWidth(), officeButtonIcon.getIconHeight());
            }

            if (root.getJMenuBar() != null && root.getJMenuBar().isVisible()) {
                JMenuBar menuBar = root.getJMenuBar();
                Dimension mbd = menuBar.getPreferredSize();
                menuBar.setBounds(43, nextY, w, mbd.height);
                nextY += mbd.height;
                boolean isMenuVisible = NbPreferences.forModule(OfficeLAFPanel.class).getBoolean("menuCheck", false);
                if(!isMenuVisible) {
                    root.getJMenuBar().setVisible(isMenuVisible);  // Mikael herjer her
                }
            }

            OfficeRootPaneUI ui = (OfficeRootPaneUI) root.getUI();
            JRibbon ribbon = ui.getRibbon();
            if (ribbon != null && ribbon.isVisible()) {
                Dimension mbd = ribbon.getPreferredSize();
//                ribbon.setBounds(0, nextY, w, mbd.height);
//                nextY += mbd.height;
                ribbon.setBounds(0, 0, w, mbd.height);
                nextY = mbd.height+0;
            }

            if (root.getContentPane() != null) {
                root.getContentPane().setBounds(0, nextY, w, h < nextY ? 0 : h - nextY);
            }
        }

        public void addLayoutComponent(String name, Component comp) {
        }

        public void removeLayoutComponent(Component comp) {
        }

        public void addLayoutComponent(Component comp, Object constraints) {
        }

        public float getLayoutAlignmentX(Container target) {
            return 0.0f;
        }

        public float getLayoutAlignmentY(Container target) {
            return 0.0f;
        }

        public void invalidateLayout(Container target) {
        }
    }
    /**
     * Maps from positions to cursor type. Refer to calculateCorner and
     * calculatePosition for details of this.
     */
    private static final int[] cursorMapping = new int[]{Cursor.NW_RESIZE_CURSOR, Cursor.NW_RESIZE_CURSOR, Cursor.N_RESIZE_CURSOR,
        Cursor.NE_RESIZE_CURSOR, Cursor.NE_RESIZE_CURSOR,
        Cursor.NW_RESIZE_CURSOR, 0, 0, 0, Cursor.NE_RESIZE_CURSOR,
        Cursor.W_RESIZE_CURSOR, 0, 0, 0, Cursor.E_RESIZE_CURSOR,
        Cursor.SW_RESIZE_CURSOR, 0, 0, 0, Cursor.SE_RESIZE_CURSOR,
        Cursor.SW_RESIZE_CURSOR, Cursor.SW_RESIZE_CURSOR, Cursor.S_RESIZE_CURSOR,
        Cursor.SE_RESIZE_CURSOR, Cursor.SE_RESIZE_CURSOR
    };

    /**
     * MouseInputHandler is responsible for handling resize/moving of
     * the Window. It sets the cursor directly on the Window when then
     * mouse moves over a hot spot.
     */
    private class MouseInputHandler implements MouseInputListener {

        /** Set to true if the drag operation is moving the window. */
        private boolean isMovingWindow;
        /** Used to determine the corner the resize is occuring from. */
        private int dragCursor;
        /** X location the mouse went down on for a drag operation. */
        private int dragOffsetX;
        /** Y location the mouse went down on for a drag operation. */
        private int dragOffsetY;
        /** Width of the window when the drag started. */
        private int dragWidth;
        /** Height of the window when the drag started. */
        private int dragHeight;

        public void mousePressed(MouseEvent ev) {
            JRootPane rootPane = getRootPane();

            if (rootPane.getWindowDecorationStyle() == JRootPane.NONE) {
                return;
            }
            Point dragWindowOffset = ev.getPoint();
            Component source = (Component) ev.getSource();
            Window w = windowForEvent(ev);
            if (w != null) {
                w.toFront();
            }
            Point convertedDragWindowOffset = SwingUtilities.convertPoint(
                    source, dragWindowOffset, getTitlePane());
            dragWindowOffset = SwingUtilities.convertPoint(
                    source, dragWindowOffset, w);

            Frame f = null;
            Dialog d = null;

            if (w instanceof Frame) {
                f = (Frame) w;
            } else if (w instanceof Dialog) {
                d = (Dialog) w;
            }

            int frameState = (f != null) ? f.getExtendedState() : 0;

            if (getTitlePane() != null &&
                    getTitlePane().contains(convertedDragWindowOffset)) {
                if ((f != null && ((frameState & Frame.MAXIMIZED_BOTH) == 0) || (d != null)) && dragWindowOffset.y >= BORDER_DRAG_THICKNESS && dragWindowOffset.x >= BORDER_DRAG_THICKNESS && dragWindowOffset.x < w.getWidth() - BORDER_DRAG_THICKNESS) {
                    isMovingWindow = true;
                    dragOffsetX = dragWindowOffset.x;
                    dragOffsetY = dragWindowOffset.y;
                }
            } else if (f != null && f.isResizable() && ((frameState & Frame.MAXIMIZED_BOTH) == 0) || (d != null && d.isResizable())) {
                dragOffsetX = dragWindowOffset.x;
                dragOffsetY = dragWindowOffset.y;
                dragWidth = w.getWidth();
                dragHeight = w.getHeight();
                dragCursor = getCursor(calculateCorner(
                        w, dragWindowOffset.x, dragWindowOffset.y));
            }
        }

        public void mouseReleased(MouseEvent ev) {
            if (dragCursor != 0 && window != null && !window.isValid()) {
                // Some Window systems validate as you resize, others won't,
                // thus the check for validity before repainting.
                window.validate();
                getRootPane().repaint();
            }
            isMovingWindow = false;
            dragCursor = 0;
        }

        public void mouseMoved(MouseEvent ev) {
            JRootPane root = getRootPane();

            if (root.getWindowDecorationStyle() == JRootPane.NONE) {
                return;
            }

            Component source = (Component) ev.getSource();
            Window w = windowForEvent(ev);
            Point pt = SwingUtilities.convertPoint(
                    source, ev.getPoint(), w);
            Frame f = null;
            Dialog d = null;

            if (w instanceof Frame) {
                f = (Frame) w;
            } else if (w instanceof Dialog) {
                d = (Dialog) w;
            }

            // Update the cursor
            int cursor = getCursor(calculateCorner(w, pt.x, pt.y));

            if (cursor != 0 && ((f != null && (f.isResizable() &&
                    (f.getExtendedState() & Frame.MAXIMIZED_BOTH) == 0)) || (d != null && d.isResizable()))) {
                w.setCursor(Cursor.getPredefinedCursor(cursor));
            } else {
                w.setCursor(lastCursor);
            }
        }

        private void adjust(Rectangle bounds, Dimension min, int deltaX,
                int deltaY, int deltaWidth, int deltaHeight) {
            bounds.x += deltaX;
            bounds.y += deltaY;
            bounds.width += deltaWidth;
            bounds.height += deltaHeight;
            if (min != null) {
                if (bounds.width < min.width) {
                    int correction = min.width - bounds.width;
                    if (deltaX != 0) {
                        bounds.x -= correction;
                    }
                    bounds.width = min.width;
                }
                if (bounds.height < min.height) {
                    int correction = min.height - bounds.height;
                    if (deltaY != 0) {
                        bounds.y -= correction;
                    }
                    bounds.height = min.height;
                }
            }
        }

        public void mouseDragged(MouseEvent ev) {
            Component source = (Component) ev.getSource();
            Window w = windowForEvent(ev);
            Point pt = SwingUtilities.convertPoint(
                    source, ev.getPoint(), w);

            if (isMovingWindow) {
                Point eventLocationOnScreen = ev.getLocationOnScreen();

                int x = eventLocationOnScreen.x - dragOffsetX;
                int y = eventLocationOnScreen.y - dragOffsetY;
                //int width = w.getWidth();
                //int height = w.getHeight();
                //System.out.println(x + ", " + y + " " + w.getPeer());

                w.setLocation(x, y);

            //w.setLocation(5000,5000);
            } else if (dragCursor != 0) {
                Rectangle r = w.getBounds();
                Rectangle startBounds = new Rectangle(r);
                Dimension min = w.getMinimumSize();

                switch (dragCursor) {
                    case Cursor.E_RESIZE_CURSOR:
                        adjust(r, min, 0, 0, pt.x + (dragWidth - dragOffsetX) -
                                r.width, 0);
                        break;
                    case Cursor.S_RESIZE_CURSOR:
                        adjust(r, min, 0, 0, 0, pt.y + (dragHeight - dragOffsetY) -
                                r.height);
                        break;
                    case Cursor.N_RESIZE_CURSOR:
                        adjust(r, min, 0, pt.y - dragOffsetY, 0,
                                -(pt.y - dragOffsetY));
                        break;
                    case Cursor.W_RESIZE_CURSOR:
                        adjust(r, min, pt.x - dragOffsetX, 0,
                                -(pt.x - dragOffsetX), 0);
                        break;
                    case Cursor.NE_RESIZE_CURSOR:
                        adjust(r, min, 0, pt.y - dragOffsetY,
                                pt.x + (dragWidth - dragOffsetX) - r.width,
                                -(pt.y - dragOffsetY));
                        break;
                    case Cursor.SE_RESIZE_CURSOR:
                        adjust(r, min, 0, 0,
                                pt.x + (dragWidth - dragOffsetX) - r.width,
                                pt.y + (dragHeight - dragOffsetY) -
                                r.height);
                        break;
                    case Cursor.NW_RESIZE_CURSOR:
                        adjust(r, min, pt.x - dragOffsetX,
                                pt.y - dragOffsetY,
                                -(pt.x - dragOffsetX),
                                -(pt.y - dragOffsetY));
                        break;
                    case Cursor.SW_RESIZE_CURSOR:
                        adjust(r, min, pt.x - dragOffsetX, 0,
                                -(pt.x - dragOffsetX),
                                pt.y + (dragHeight - dragOffsetY) - r.height);
                        break;
                    default:
                        break;
                }
                if (!r.equals(startBounds)) {
                    w.setBounds(r.x, r.y, r.width, r.height);

                    // Defer repaint/validate on mouseReleased unless dynamic
                    // layout is active.
                    if (Toolkit.getDefaultToolkit().isDynamicLayoutActive()) {
                        w.validate();
                        getRootPane().repaint();
                    }
                }
            }
        }

        public void mouseEntered(MouseEvent ev) {
            Window w = windowForEvent(ev);
            lastCursor = w.getCursor();
            mouseMoved(ev);
        }

        public void mouseExited(MouseEvent ev) {
            Window w = windowForEvent(ev);
            w.setCursor(lastCursor);
        }

        public void mouseClicked(MouseEvent ev) {
            Component source = (Component) ev.getSource();
            Window w = windowForEvent(ev);
            Frame f;

            if (w instanceof Frame) {
                f = (Frame) w;
            } else {
                return;
            }

            Point convertedPoint = SwingUtilities.convertPoint(
                    source, ev.getPoint(), getTitlePane());

            int state = f.getExtendedState();
            if (getTitlePane() != null &&
                    getTitlePane().contains(convertedPoint)) {
                if ((ev.getClickCount() % 2) == 0 &&
                        ((ev.getModifiers() & InputEvent.BUTTON1_MASK) != 0)) {
                    if (f.isResizable()) {
                        if ((state & Frame.MAXIMIZED_BOTH) != 0) {
                            f.setExtendedState(state & ~Frame.MAXIMIZED_BOTH);
                        } else {
                            f.setExtendedState(state | Frame.MAXIMIZED_BOTH);
                        }
                    }
                }
            }
        }

        /**
         * Returns the corner that contains the point <code>x</code>,
         * <code>y</code>, or -1 if the position doesn't match a corner.
         */
        private int calculateCorner(Window w, int x, int y) {
            Insets insets = w.getInsets();
            int xPosition = calculatePosition(x - insets.left,
                    w.getWidth() - insets.left - insets.right);
            int yPosition = calculatePosition(y - insets.top,
                    w.getHeight() - insets.top - insets.bottom);

            if (xPosition == -1 || yPosition == -1) {
                return -1;
            }
            return yPosition * 5 + xPosition;
        }

        /**
         * Returns the Cursor to render for the specified corner. This returns
         * 0 if the corner doesn't map to a valid Cursor
         */
        private int getCursor(int corner) {
            if (corner == -1) {
                return 0;
            }
            return cursorMapping[corner];
        }

        /**
         * Returns an integer indicating the position of <code>spot</code>
         * in <code>width</code>. The return value will be:
         * 0 if < BORDER_DRAG_THICKNESS
         * 1 if < CORNER_DRAG_WIDTH
         * 2 if >= CORNER_DRAG_WIDTH && < width - BORDER_DRAG_THICKNESS
         * 3 if >= width - CORNER_DRAG_WIDTH
         * 4 if >= width - BORDER_DRAG_THICKNESS
         * 5 otherwise
         */
        private int calculatePosition(int spot, int width) {
            if (spot < BORDER_DRAG_THICKNESS) {
                return 0;
            }
            if (spot < CORNER_DRAG_WIDTH) {
                return 1;
            }
            if (spot >= (width - BORDER_DRAG_THICKNESS)) {
                return 4;
            }
            if (spot >= (width - CORNER_DRAG_WIDTH)) {
                return 3;
            }
            return 2;
        }

        private Window windowForEvent(MouseEvent ev) {
            Component source = (Component) ev.getSource();
            return source instanceof Window ? (Window) source : SwingUtilities.getWindowAncestor(source);
        }
    }

    public static void main(String[] args) throws Exception {
        UIManager.setLookAndFeel(new OfficeWindowsLookAndFeel());

        JFrame frame = new JFrame("Ogzy");
        JMenuBar menuBar = new JMenuBar();
        JMenu file = new JMenu("Plik");
        file.add(new JMenuItem("Wyjście"));
        menuBar.add(file);
        frame.setJMenuBar(menuBar);

        frame.setSize(800, 600);
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel contentPane = new JPanel(new BorderLayout());
        contentPane.setBackground(Color.RED);

        JPanel inner = new JPanel();
        inner.setBackground(Color.GREEN);
        contentPane.add(inner, BorderLayout.CENTER);

        frame.setContentPane(contentPane);

        frame.setVisible(true);
    }
}